<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>11.13</title>
</head>

<body>
    <script>
        //1合并两个有序数组
        // 给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
        // 请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
        // 注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，
        //其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
        //         ：[1,2,2,3,5,6]
        // 解释：需要合并 [1,2,3] 和 [2,5,6] 。
        // function one() {
        //     let nums1 = [1, 2, 3, 0, 0, 0], m = 3, nums2 = [2, 5, 6], n = 3;
        //     let nums3 = [];
        //     for (let i = 0; i < nums1.length; i++) {
        //         if (nums1[i] !== 0) {
        //             nums3.push(nums1[i])
        //         }
        //     }
        //     nums1 = nums3;
        //     for (let j = 0; j < nums2.length; j++) {
        //         nums1.push(nums2[j])
        //     }
        //     // console.log(nums1)
        //     for (let i = 0; i < nums1.length; i++) {
        //         for (let j = 0; j < nums1.length - i - 1; j++) {
        //             if (nums1[j] > nums1[j + 1]) {
        //                 let temp = nums1[j];
        //                 nums1[j] = nums1[j + 1];
        //                 nums1[j + 1] = temp
        //             }
        //         }
        //     }
        //     console.log(nums1)
        // }
        // one()

        // 2移除元素
        // 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
        // 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
        // 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
        // 例如：
        // let nums = [3,2,2,3], val = 3;
        // function two(){
        //     for(let i=0;i<nums.length;i++){
        //         if(nums[i]==val){
        //             nums.splice(i,1)
        //         }
        //     }
        //     return nums.length
        // }
        // console.log(two())

        // 3删除有序数组中的重复项 II
        // 给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。
        // 不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
        // 例如：
        // let nums = [1,1,1,2,2,3];
        // let count=0;
        // let obj={}
        // let who;
        // function three(){
        //     for(let i=0;i<nums.length;i++){
        //         if(obj[nums[i]]){
        //             obj[nums[i]]++
        //         }else{
        //             obj[nums[i]]=1
        //         }
        //     }
        //     for (const key in obj) {
        //         // console.log(obj[key],key)
        //         if(obj[key]>=3){
        //         who=key;
        //         count=obj[key]
        //         }
        //     }
        //     for(let i=0;i<nums.length;i++){
        //         if(nums[i]==who){
        //             if(count>=3){
        //                 nums.splice(i,1);
        //                 count--
        //             }
        //             // console.log(nums[i])
        //         }
        //     }
        //     return nums.length
        // }
        // console.log(three())

        //4跳跃游戏
        // 给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。
        // 判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。

        // 例如：    0 1 2 3 4
        // let nums = [2,3,1,1,4]   //下标为4 
        // let first=nums[0]+0;        //2
        // // // let second=nums[first]+first;   //1+2 =3
        // // // let third=nums[second]+second;  //1+3=4
        // // // console.log(third);
        // let result;
        // function four(){
        //     for(let i=0;i<nums.length;i++){
        //         first=nums[first]+first
        //         if(first==nums.length-1){
        //             result=true
        //             break
        //         }else{
        //             result=false;
        //             break
        //         }
        //     }
        // }
        // four()
        // console.log(result)

        // 5.三数之和
        // 给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，
        //同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
        // 你返回所有和为 0 且不重复的三元组。
        // 注意：答案中不可以包含重复的三元组。
        // 例如：
        // let nums = [-1, 0, 1, 2, -1, -4]
        // let newarr = [];
        // let obj = {};
        // function five() {
        //     for (let i = 0; i < nums.length; i++) {
        //         for (let j = 0; j < nums.length; j++) {
        //             for (let k = 0; k < nums.length; k++) {
        //                 // console.log(nums[i],nums[j],nums[k])
        //                 if (i != j && i != k && j != k) {
        //                     if (nums[i] + nums[j] + nums[k] == 0) {
        //                         // console.log(nums[i],nums[j],nums[k])
        //                         arr = [nums[i], nums[j], nums[k]]
        //                         // 来排序
        //                         for (let l = 0; l < arr.length; l++) {
        //                             for (let z = 0; z < arr.length - l - 1; z++) {
        //                                 // console.log(arr[l],arr[z])
        //                                 if (arr[z] < arr[z + 1]) {
        //                                     let temp = arr[z];
        //                                     arr[z] = arr[z + 1];
        //                                     arr[z + 1] = temp
        //                                 }
        //                             }
        //                         }
        //                         newarr.push(arr)
        //                     }
        //                     // break
        //                 }
        //                 break
        //             }
        //         }
        //     }
        //     // console.log(newarr);
        //     let count = 1;
        //     for (let i = 0; i < newarr.length; i++) {
        //         if (obj[newarr[i]]) {
        //             count++
        //             console.log(count)
        //             // obj[newarr[i]]++n
        //             newarr.splice(i, count)
        //         } else {
        //             obj[newarr[i]] = 1
        //         }
        //     }
        //     // console.log(newarr);
        //     for (let i = 0; i < newarr.length; i++) {
        //         console.log(newarr[i])
        //     }
        // }
        // five()

        // 6.判断子序列
        // 给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
        // 字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
        // 例如输入：
        // let s = "abg", t = "achbgd"
        // let index=0; //下标
        // for(let i=0;i<t.length;i++){
        //     // console.log(t[i])
        //     for(let j=0;j<s.length;j++){   
        //         if(s[j]==t[i]){
        //           console.log(j)
        //           if(index<=j){
        //             index=j
        //           }else{
        //             console.log("判断s不是t的子序列。")
        //           }
        //         }
        //     }
        // }

        //7.最长公共前缀
        // 编写一个函数来查找字符串数组中的最长公共前缀。
        // 如果不存在公共前缀，返回空字符串 ""。
        // 输入：输出："fl"
        // let strs = ["flower","flow","flight"];
        // if(strs[0][0]==strs[1][0]&&strs[2][0]==strs[0][0]){
        //    if(strs[0][1]==strs[1][1]&&strs[2][1]==strs[0][1]){
        //     console.log(strs[0].slice(0,2))
        //    }
        // }else{
        //     console.log(" ")
        // }

        //8.最后一个单词的长度
        // 给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
        // 单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
        // 输入：输出：5
        // let s = "Hello World"
        // let arr=s.split(" ");
        // for(let i=0;i<arr.length;i++){
        //     console.log(arr[arr.length-1].length);
        // }

        //9. 整数转罗马数字
        // 罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。
        // 字符          数值
        // I             1
        // V             5
        // X             10
        // L             50
        // C             100
        // D             500
        // M             1000
        // 例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。
        // 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
        // I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
        // X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
        // C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
        // 给你一个整数，将其转为罗马数字。
        // 输入: num = 1994   IIXIXVI

        //10. 轮转数组
        // 给定一个整数数组 nums，将数组中的元素向右轮转 k个位置，其中 k是非负数。
        // 示例 1:
        // 输入: nums = [1,2,3,4,5,6,7], k = 3输出: [5,6,7,1,2,3,4]解释:
        // 向右轮转 1 步: [7,1,2,3,4,5,6]
        // 向右轮转 2 步: [6,7,1,2,3,4,5]向右轮转 3 步: [5,6,7,1,2,3,4]

        // 输入：
        // let nums = [-1,-100,3,99], k = 2
        // for(let i=0;i<k;i++){
        //     let a=nums.pop();
        //     nums.unshift(a);
        // }
        // console.log(nums)

        // 11. 给你一个二维整数数组 envelopes ，其中 envelopes[i] = [wi, hi] ，表示第 i 个信封的宽度和高度。
        // 当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。
        // 请计算 最多能有多少个 信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。
        // 注意：不允许旋转信封。
        // 示例 1：
        // 输入：envelopes = [[5,4],[6,4],[6,7],[2,3]]输出：3解释：最多信封的个数为 3, 组合为: [2,3] => [5,4] => [6,7]。
        let envelopes = [[5,4],[6,4],[6,7],[2,3]];
        let sort=envelopes.sort((a,b)=>{
            return a[0]-b[0]
        })
        console.log(sort)
        let count=0;
        for(let i=0;i<envelopes.length;i++){
           for(let j=0;j<envelopes.length-i-1;j++){
            if(envelopes[j][0]<envelopes[j+1][0]&&envelopes[j][1]<envelopes[j+1][1]){
                count++
            }
           }
        }
        console.log(count)

        // let width="";
        // let height="";
        // // 找到最小 找到最大
        // let arr=[];
        // for(let i=0;i<envelopes.length;i++){
        //     arr.push(envelopes[i][0])
        // }
        // let min=1000;   //2
        // let max=0;      //6
        // for(let i=0;i<arr.length;i++){
        //     if(arr[i]<min){
        //         min=arr[i]
        //     }
        //     if(arr[i]>max){
        //         max=arr[i]
        //     }
        // }
        // let minarr=[];
        // let maxarr=[];
        // // 相比较一下最大的
        // let sixmax=0;
        // for(let i=0;i<envelopes.length;i++){
        //     if(envelopes[i][0]==min){
        //         minarr=envelopes[i] //最小
        //     }else if(envelopes[i][0]==max){
        //         // console.log(envelopes[i][1])  //最大
        //         if(sixmax<envelopes[i][1]){
        //             sixmax=envelopes[i][1]
        //             maxarr=envelopes[i]
        //         }
        //     }
        // }
        // console.log(minarr,maxarr)
    </script>
</body>

</html>